template<
	typename element_t,
	typename allocator_t = std::allocator<element_t>,
	typename requested_stride_to_projector_and_accumulator_map_t = std::tuple<>
> struct augmented_deque_t;

• An augmented_deque_t has at least one sub-sequences, each having a compile-time or run-time specified stride (if run-time specified, can be adjusted at any time, although does not affect grouping of already enququed elements), an optional projector and an optional accumulator. Container elements are shared between all sub-sequences and are stored in sub-sequence 0. In every subsequence, every neighboring stride elements are projected into a projected result (if stride is compile-time specified and equals to 1, this step can be skipped), then accumulated into an accumulated result (this step can also be skipped if you only need the projected result; on sub-sequences other than sub-sequence 0 whose stride is compile-time specified and equals to 1, it's meaningless to skip both projection and accumulation steps and thus is not allowed).
• augmented_deque_t allows range update: first modify some elements, then call update_range to refresh the projected results and accumulated results that covers those elements in O(distance(range)+(lg(N)-lg(distance(range)))) time (as elements are organized in prefect binary trees, the number of most of the internal nodes to be updated is O(distance(range))). A common mistake would be to forget to call update_range.
• augmented_deque_t allows subrange query: call read_range to collect projected results and accumulated results that covers the range in O(lg(distance(range))) time. If the accumulated result is a range instead of a single value, the result is probably formed by projected results linking to each other, in this case you should not call read_range because there are no more pointers left for you to form another range (see examples below for an intuitive feel).
• augmented_deque_t does not allow inserting or removing elements in the middle. Having this restriction allows it to privide the striding functionality (which the more general augmented_sequence_t can not provide.)

• When enqueue operations comes consecutively, the most frequent operation is new tree_node_t whose number is equal to the number of internal nodes in perfect binary trees which is less than the number of elements. (Carrying at position $i$ ($i\in \mathbb{N}$) happens every $2^i$ enqueue operations, so every enqueue operation pays $\frac{1}{2^i}$ points of energy for each position $i$ (O(1) points of energy for all positions in sum).)
• When dequeue operations comes consecutively, the most frequent operation is delete p_tree_node whose number is equal to the number of internal nodes in perfect binary trees which is less than the number of elements.
• When enqueue and dequeue operations comes alternately, in order to prevent cascading carrying and borrowing between numbers like 0b01111111 and 0b10000000, a modified binary positional numeral system which allows each position to be 0, 1 or 2, is used:

augmented_containers::augmented_deque_t<
	char,
	std::allocator<char>
> augmented_deque;

augmented_containers::augmented_deque_t<
	char,
	std::allocator<char>,
	std::tuple<
		std::pair<std::integral_constant<std::size_t, 1>, augmented_containers::augmented_deque_helpers::example_stride1_chunk1_projector_skipped_and_accumulator_sequence_t<char, std::string>>
	>
>

augmented_containers::augmented_deque_t<
	int,
	std::allocator<int>,
	std::tuple<
		std::pair<std::integral_constant<std::size_t, 1>, augmented_containers::augmented_deque_helpers::example_stride1_chunk1_projector_skipped_and_accumulator_plus_t<int>>,
		std::pair<std::integral_constant<std::size_t, 3>, augmented_containers::augmented_deque_helpers::example_chunkgt1_projector_max_element_and_accumulator_min_t<int>>
	>
> augmented_deque;

augmented_containers::augmented_deque_t<
	std::string,
	std::allocator<std::string>,
	std::tuple<
		std::pair<std::integral_constant<std::size_t, 1>, augmented_containers::augmented_deque_helpers::example_stride1_chunk1_projector_skipped_and_accumulator_plus_t<std::string>>,
		std::pair<std::integral_constant<std::size_t, 3>, augmented_containers::augmented_deque_helpers::example_chunkgt1_projector_max_element_and_accumulator_min_t<std::string>>
	>
> augmented_deque;

augmented_containers::augmented_deque_t<
	int,
	std::allocator<int>,
	std::tuple<
		//std::pair<std::integral_constant<std::size_t, 3>, projector_and_accumulator_min_n_element_t<int, 3>>, //commented one of the sub-sequences because it looks messy when there are three images stacked together
		std::pair<std::integral_constant<std::size_t, 3>, projector_and_accumulator_min_n_element_t<int, 3, true>>
	>
> augmented_deque;

augmented_containers::augmented_deque_t<
	int,
	std::allocator<int>,
	std::tuple<
		std::pair<std::integral_constant<std::size_t, 1>, projector_and_accumulator_diffing_adjacent_element_t>
	>
> augmented_deque;

augmented_containers::augmented_deque_t<
	int,
	std::allocator<int>,
	std::tuple<
		std::pair<std::integral_constant<std::size_t, 1>, projector_and_accumulator_group_by_t>
	>
> augmented_deque;